// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.amazon.financial.event.group;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.AmazonFinancialEventGroup;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(AmazonFinancialEventGroup.class)
@Setter
@Getter
public class AmazonFinancialEventGroupSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "AmazonFinancialEventGroup".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("sid", "si");
    map.put("countryCode", "sc");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 结算编号(模糊搜索)
   */
  private String fid;

  /**
   * 结算编号 比较(eq)
   */
  private String fidEq;
  /**
   * 结算编号 比较(neq)
   */
  private String fidNeq;
  /**
   * 结算编号 比较(gt)
   */
  private String fidGt;
  /**
   * 结算编号 比较(gte)
   */
  private String fidGte;
  /**
   * 结算编号 比较(lt)
   */
  private String fidLt;
  /**
   * 结算编号 比较(lte)
   */
  private String fidLte;
  /**
   * 结算编号 比较(contains)
   */
  private String fidContains;
  /**
   * 结算编号 比较(notcontains)
   */
  private String fidNotcontains;
  /**
   * 结算编号 比较(startswith)
   */
  private String fidStartswith;
  /**
   * 结算编号 比较(endswith)
   */
  private String fidEndswith;
  /**
   * 结算编号 比较(isnull)
   */
  private Boolean fidIsnull;
  /**
   * 结算编号 比较(isnotnull)
   */
  private Boolean fidIsnotnull;

  /**
   * 结算编号(精确搜索)
   */
  private List<String> fidInList;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String sidShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String sidShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String sidShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String sidShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String sidShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String sidShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String sidShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String sidShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String sidShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String sidShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean sidShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean sidShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> sidInList;

  /**
   * 店铺名称(模糊搜索)
   */
  private String storeName;

  /**
   * 店铺名称 比较(eq)
   */
  private String storeNameEq;
  /**
   * 店铺名称 比较(neq)
   */
  private String storeNameNeq;
  /**
   * 店铺名称 比较(gt)
   */
  private String storeNameGt;
  /**
   * 店铺名称 比较(gte)
   */
  private String storeNameGte;
  /**
   * 店铺名称 比较(lt)
   */
  private String storeNameLt;
  /**
   * 店铺名称 比较(lte)
   */
  private String storeNameLte;
  /**
   * 店铺名称 比较(contains)
   */
  private String storeNameContains;
  /**
   * 店铺名称 比较(notcontains)
   */
  private String storeNameNotcontains;
  /**
   * 店铺名称 比较(startswith)
   */
  private String storeNameStartswith;
  /**
   * 店铺名称 比较(endswith)
   */
  private String storeNameEndswith;
  /**
   * 店铺名称 比较(isnull)
   */
  private Boolean storeNameIsnull;
  /**
   * 店铺名称 比较(isnotnull)
   */
  private Boolean storeNameIsnotnull;

  /**
   * 店铺名称(精确搜索)
   */
  private List<String> storeNameInList;

  /**
   * 国家
   */
  private Long countryCode;

  /**
   * 国家 比较(eq)
   */
  private Long countryCodeEq;
  /**
   * 国家 比较(neq)
   */
  private Long countryCodeNeq;
  /**
   * 国家 比较(gt)
   */
  private Long countryCodeGt;
  /**
   * 国家 比较(gte)
   */
  private Long countryCodeGte;
  /**
   * 国家 比较(lt)
   */
  private Long countryCodeLt;
  /**
   * 国家 比较(lte)
   */
  private Long countryCodeLte;
  /**
   * 国家 比较(contains)
   */
  private Long countryCodeContains;
  /**
   * 国家 比较(notcontains)
   */
  private Long countryCodeNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private Long countryCodeStartswith;
  /**
   * 国家 比较(endswith)
   */
  private Long countryCodeEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryCodeIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryCodeIsnotnull;
  /**
   * 国家的国家 比较(eq)
   */
  private String countryCodeCountryEq;
  /**
   * 国家的国家 比较(neq)
   */
  private String countryCodeCountryNeq;
  /**
   * 国家的国家 比较(gt)
   */
  private String countryCodeCountryGt;
  /**
   * 国家的国家 比较(gte)
   */
  private String countryCodeCountryGte;
  /**
   * 国家的国家 比较(lt)
   */
  private String countryCodeCountryLt;
  /**
   * 国家的国家 比较(lte)
   */
  private String countryCodeCountryLte;
  /**
   * 国家的国家 比较(contains)
   */
  private String countryCodeCountryContains;
  /**
   * 国家的国家 比较(notcontains)
   */
  private String countryCodeCountryNotcontains;
  /**
   * 国家的国家 比较(startswith)
   */
  private String countryCodeCountryStartswith;
  /**
   * 国家的国家 比较(endswith)
   */
  private String countryCodeCountryEndswith;
  /**
   * 国家的国家 比较(isnull)
   */
  private Boolean countryCodeCountryIsnull;
  /**
   * 国家的国家 比较(isnotnull)
   */
  private Boolean countryCodeCountryIsnotnull;

  /**
   * 国家(范围搜索)
   */
  private List<Long> countryCodeInList;

  /**
   * 国家code(模糊搜索)
   */
  private String customerCountryCode;

  /**
   * 国家code 比较(eq)
   */
  private String customerCountryCodeEq;
  /**
   * 国家code 比较(neq)
   */
  private String customerCountryCodeNeq;
  /**
   * 国家code 比较(gt)
   */
  private String customerCountryCodeGt;
  /**
   * 国家code 比较(gte)
   */
  private String customerCountryCodeGte;
  /**
   * 国家code 比较(lt)
   */
  private String customerCountryCodeLt;
  /**
   * 国家code 比较(lte)
   */
  private String customerCountryCodeLte;
  /**
   * 国家code 比较(contains)
   */
  private String customerCountryCodeContains;
  /**
   * 国家code 比较(notcontains)
   */
  private String customerCountryCodeNotcontains;
  /**
   * 国家code 比较(startswith)
   */
  private String customerCountryCodeStartswith;
  /**
   * 国家code 比较(endswith)
   */
  private String customerCountryCodeEndswith;
  /**
   * 国家code 比较(isnull)
   */
  private Boolean customerCountryCodeIsnull;
  /**
   * 国家code 比较(isnotnull)
   */
  private Boolean customerCountryCodeIsnotnull;

  /**
   * 国家code(精确搜索)
   */
  private List<String> customerCountryCodeInList;

  /**
   * 亚马逊账号id(模糊搜索)
   */
  private String sellerId;

  /**
   * 亚马逊账号id 比较(eq)
   */
  private String sellerIdEq;
  /**
   * 亚马逊账号id 比较(neq)
   */
  private String sellerIdNeq;
  /**
   * 亚马逊账号id 比较(gt)
   */
  private String sellerIdGt;
  /**
   * 亚马逊账号id 比较(gte)
   */
  private String sellerIdGte;
  /**
   * 亚马逊账号id 比较(lt)
   */
  private String sellerIdLt;
  /**
   * 亚马逊账号id 比较(lte)
   */
  private String sellerIdLte;
  /**
   * 亚马逊账号id 比较(contains)
   */
  private String sellerIdContains;
  /**
   * 亚马逊账号id 比较(notcontains)
   */
  private String sellerIdNotcontains;
  /**
   * 亚马逊账号id 比较(startswith)
   */
  private String sellerIdStartswith;
  /**
   * 亚马逊账号id 比较(endswith)
   */
  private String sellerIdEndswith;
  /**
   * 亚马逊账号id 比较(isnull)
   */
  private Boolean sellerIdIsnull;
  /**
   * 亚马逊账号id 比较(isnotnull)
   */
  private Boolean sellerIdIsnotnull;

  /**
   * 亚马逊账号id(精确搜索)
   */
  private List<String> sellerIdInList;

  /**
   * 报告类型(模糊搜索)
   */
  private String reportType;

  /**
   * 报告类型 比较(eq)
   */
  private String reportTypeEq;
  /**
   * 报告类型 比较(neq)
   */
  private String reportTypeNeq;
  /**
   * 报告类型 比较(gt)
   */
  private String reportTypeGt;
  /**
   * 报告类型 比较(gte)
   */
  private String reportTypeGte;
  /**
   * 报告类型 比较(lt)
   */
  private String reportTypeLt;
  /**
   * 报告类型 比较(lte)
   */
  private String reportTypeLte;
  /**
   * 报告类型 比较(contains)
   */
  private String reportTypeContains;
  /**
   * 报告类型 比较(notcontains)
   */
  private String reportTypeNotcontains;
  /**
   * 报告类型 比较(startswith)
   */
  private String reportTypeStartswith;
  /**
   * 报告类型 比较(endswith)
   */
  private String reportTypeEndswith;
  /**
   * 报告类型 比较(isnull)
   */
  private Boolean reportTypeIsnull;
  /**
   * 报告类型 比较(isnotnull)
   */
  private Boolean reportTypeIsnotnull;

  /**
   * 报告类型(精确搜索)
   */
  private List<String> reportTypeInList;

  /**
   * 结算状态
   */
  private String processingStatus;

  /**
   * 结算状态 比较(eq)
   */
  private String processingStatusEq;
  /**
   * 结算状态 比较(neq)
   */
  private String processingStatusNeq;
  /**
   * 结算状态 比较(gt)
   */
  private String processingStatusGt;
  /**
   * 结算状态 比较(gte)
   */
  private String processingStatusGte;
  /**
   * 结算状态 比较(lt)
   */
  private String processingStatusLt;
  /**
   * 结算状态 比较(lte)
   */
  private String processingStatusLte;
  /**
   * 结算状态 比较(contains)
   */
  private String processingStatusContains;
  /**
   * 结算状态 比较(notcontains)
   */
  private String processingStatusNotcontains;
  /**
   * 结算状态 比较(startswith)
   */
  private String processingStatusStartswith;
  /**
   * 结算状态 比较(endswith)
   */
  private String processingStatusEndswith;
  /**
   * 结算状态 比较(isnull)
   */
  private Boolean processingStatusIsnull;
  /**
   * 结算状态 比较(isnotnull)
   */
  private Boolean processingStatusIsnotnull;

  /**
   * 结算状态(精确搜索)
   */
  private List<String> processingStatusInList;

  /**
   * 转账状态
   */
  private String fundTransferStatus;

  /**
   * 转账状态 比较(eq)
   */
  private String fundTransferStatusEq;
  /**
   * 转账状态 比较(neq)
   */
  private String fundTransferStatusNeq;
  /**
   * 转账状态 比较(gt)
   */
  private String fundTransferStatusGt;
  /**
   * 转账状态 比较(gte)
   */
  private String fundTransferStatusGte;
  /**
   * 转账状态 比较(lt)
   */
  private String fundTransferStatusLt;
  /**
   * 转账状态 比较(lte)
   */
  private String fundTransferStatusLte;
  /**
   * 转账状态 比较(contains)
   */
  private String fundTransferStatusContains;
  /**
   * 转账状态 比较(notcontains)
   */
  private String fundTransferStatusNotcontains;
  /**
   * 转账状态 比较(startswith)
   */
  private String fundTransferStatusStartswith;
  /**
   * 转账状态 比较(endswith)
   */
  private String fundTransferStatusEndswith;
  /**
   * 转账状态 比较(isnull)
   */
  private Boolean fundTransferStatusIsnull;
  /**
   * 转账状态 比较(isnotnull)
   */
  private Boolean fundTransferStatusIsnotnull;

  /**
   * 转账状态(精确搜索)
   */
  private List<String> fundTransferStatusInList;

  /**
   * 对账结果
   */
  private String reconciliationResults;

  /**
   * 对账结果 比较(eq)
   */
  private String reconciliationResultsEq;
  /**
   * 对账结果 比较(neq)
   */
  private String reconciliationResultsNeq;
  /**
   * 对账结果 比较(gt)
   */
  private String reconciliationResultsGt;
  /**
   * 对账结果 比较(gte)
   */
  private String reconciliationResultsGte;
  /**
   * 对账结果 比较(lt)
   */
  private String reconciliationResultsLt;
  /**
   * 对账结果 比较(lte)
   */
  private String reconciliationResultsLte;
  /**
   * 对账结果 比较(contains)
   */
  private String reconciliationResultsContains;
  /**
   * 对账结果 比较(notcontains)
   */
  private String reconciliationResultsNotcontains;
  /**
   * 对账结果 比较(startswith)
   */
  private String reconciliationResultsStartswith;
  /**
   * 对账结果 比较(endswith)
   */
  private String reconciliationResultsEndswith;
  /**
   * 对账结果 比较(isnull)
   */
  private Boolean reconciliationResultsIsnull;
  /**
   * 对账结果 比较(isnotnull)
   */
  private Boolean reconciliationResultsIsnotnull;

  /**
   * 对账结果(精确搜索)
   */
  private List<String> reconciliationResultsInList;

  /**
   * 对账结果内容(模糊搜索)
   */
  private String reconciliationResultsBody;

  /**
   * 对账结果内容 比较(eq)
   */
  private String reconciliationResultsBodyEq;
  /**
   * 对账结果内容 比较(neq)
   */
  private String reconciliationResultsBodyNeq;
  /**
   * 对账结果内容 比较(gt)
   */
  private String reconciliationResultsBodyGt;
  /**
   * 对账结果内容 比较(gte)
   */
  private String reconciliationResultsBodyGte;
  /**
   * 对账结果内容 比较(lt)
   */
  private String reconciliationResultsBodyLt;
  /**
   * 对账结果内容 比较(lte)
   */
  private String reconciliationResultsBodyLte;
  /**
   * 对账结果内容 比较(contains)
   */
  private String reconciliationResultsBodyContains;
  /**
   * 对账结果内容 比较(notcontains)
   */
  private String reconciliationResultsBodyNotcontains;
  /**
   * 对账结果内容 比较(startswith)
   */
  private String reconciliationResultsBodyStartswith;
  /**
   * 对账结果内容 比较(endswith)
   */
  private String reconciliationResultsBodyEndswith;
  /**
   * 对账结果内容 比较(isnull)
   */
  private Boolean reconciliationResultsBodyIsnull;
  /**
   * 对账结果内容 比较(isnotnull)
   */
  private Boolean reconciliationResultsBodyIsnotnull;

  /**
   * 对账结果内容(精确搜索)
   */
  private List<String> reconciliationResultsBodyInList;

  /**
   * 应收币种
   */
  private String originalTotalCurrencyCode;

  /**
   * 应收币种 比较(eq)
   */
  private String originalTotalCurrencyCodeEq;
  /**
   * 应收币种 比较(neq)
   */
  private String originalTotalCurrencyCodeNeq;
  /**
   * 应收币种 比较(gt)
   */
  private String originalTotalCurrencyCodeGt;
  /**
   * 应收币种 比较(gte)
   */
  private String originalTotalCurrencyCodeGte;
  /**
   * 应收币种 比较(lt)
   */
  private String originalTotalCurrencyCodeLt;
  /**
   * 应收币种 比较(lte)
   */
  private String originalTotalCurrencyCodeLte;
  /**
   * 应收币种 比较(contains)
   */
  private String originalTotalCurrencyCodeContains;
  /**
   * 应收币种 比较(notcontains)
   */
  private String originalTotalCurrencyCodeNotcontains;
  /**
   * 应收币种 比较(startswith)
   */
  private String originalTotalCurrencyCodeStartswith;
  /**
   * 应收币种 比较(endswith)
   */
  private String originalTotalCurrencyCodeEndswith;
  /**
   * 应收币种 比较(isnull)
   */
  private Boolean originalTotalCurrencyCodeIsnull;
  /**
   * 应收币种 比较(isnotnull)
   */
  private Boolean originalTotalCurrencyCodeIsnotnull;

  /**
   * 应收币种(精确搜索)
   */
  private List<String> originalTotalCurrencyCodeInList;

  /**
   * 转账币种
   */
  private String convertedTotalCurrencyCode;

  /**
   * 转账币种 比较(eq)
   */
  private String convertedTotalCurrencyCodeEq;
  /**
   * 转账币种 比较(neq)
   */
  private String convertedTotalCurrencyCodeNeq;
  /**
   * 转账币种 比较(gt)
   */
  private String convertedTotalCurrencyCodeGt;
  /**
   * 转账币种 比较(gte)
   */
  private String convertedTotalCurrencyCodeGte;
  /**
   * 转账币种 比较(lt)
   */
  private String convertedTotalCurrencyCodeLt;
  /**
   * 转账币种 比较(lte)
   */
  private String convertedTotalCurrencyCodeLte;
  /**
   * 转账币种 比较(contains)
   */
  private String convertedTotalCurrencyCodeContains;
  /**
   * 转账币种 比较(notcontains)
   */
  private String convertedTotalCurrencyCodeNotcontains;
  /**
   * 转账币种 比较(startswith)
   */
  private String convertedTotalCurrencyCodeStartswith;
  /**
   * 转账币种 比较(endswith)
   */
  private String convertedTotalCurrencyCodeEndswith;
  /**
   * 转账币种 比较(isnull)
   */
  private Boolean convertedTotalCurrencyCodeIsnull;
  /**
   * 转账币种 比较(isnotnull)
   */
  private Boolean convertedTotalCurrencyCodeIsnotnull;

  /**
   * 转账币种(精确搜索)
   */
  private List<String> convertedTotalCurrencyCodeInList;

  /**
   * 转账金额
   */
  private java.math.BigDecimal convertedTotal;

  /**
   * 最小转账金额
   */
  private java.math.BigDecimal convertedTotalMin;

  /**
   * 最大转账金额
   */
  private java.math.BigDecimal convertedTotalMax;

  /**
   * 转账金额 比较(eq)
   */
  private java.math.BigDecimal convertedTotalEq;
  /**
   * 转账金额 比较(neq)
   */
  private java.math.BigDecimal convertedTotalNeq;
  /**
   * 转账金额 比较(gt)
   */
  private java.math.BigDecimal convertedTotalGt;
  /**
   * 转账金额 比较(gte)
   */
  private java.math.BigDecimal convertedTotalGte;
  /**
   * 转账金额 比较(lt)
   */
  private java.math.BigDecimal convertedTotalLt;
  /**
   * 转账金额 比较(lte)
   */
  private java.math.BigDecimal convertedTotalLte;
  /**
   * 转账金额 比较(contains)
   */
  private java.math.BigDecimal convertedTotalContains;
  /**
   * 转账金额 比较(notcontains)
   */
  private java.math.BigDecimal convertedTotalNotcontains;
  /**
   * 转账金额 比较(startswith)
   */
  private java.math.BigDecimal convertedTotalStartswith;
  /**
   * 转账金额 比较(endswith)
   */
  private java.math.BigDecimal convertedTotalEndswith;
  /**
   * 转账金额 比较(isnull)
   */
  private Boolean convertedTotalIsnull;
  /**
   * 转账金额 比较(isnotnull)
   */
  private Boolean convertedTotalIsnotnull;

  /**
   * 备注(模糊搜索)
   */
  private String comment;

  /**
   * 备注 比较(eq)
   */
  private String commentEq;
  /**
   * 备注 比较(neq)
   */
  private String commentNeq;
  /**
   * 备注 比较(gt)
   */
  private String commentGt;
  /**
   * 备注 比较(gte)
   */
  private String commentGte;
  /**
   * 备注 比较(lt)
   */
  private String commentLt;
  /**
   * 备注 比较(lte)
   */
  private String commentLte;
  /**
   * 备注 比较(contains)
   */
  private String commentContains;
  /**
   * 备注 比较(notcontains)
   */
  private String commentNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String commentStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String commentEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean commentIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean commentIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> commentInList;

  /**
   * 最早结算开始时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementStartDateStart;

  /**
   * 最晚结算开始时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementStartDateEnd;

  /**
   * 结算开始时间 比较(eq)
   */
  private Date settlementStartDateEq;
  /**
   * 结算开始时间 比较(neq)
   */
  private Date settlementStartDateNeq;
  /**
   * 结算开始时间 比较(gt)
   */
  private Date settlementStartDateGt;
  /**
   * 结算开始时间 比较(gte)
   */
  private Date settlementStartDateGte;
  /**
   * 结算开始时间 比较(lt)
   */
  private Date settlementStartDateLt;
  /**
   * 结算开始时间 比较(lte)
   */
  private Date settlementStartDateLte;
  /**
   * 结算开始时间 比较(contains)
   */
  private Date settlementStartDateContains;
  /**
   * 结算开始时间 比较(notcontains)
   */
  private Date settlementStartDateNotcontains;
  /**
   * 结算开始时间 比较(startswith)
   */
  private Date settlementStartDateStartswith;
  /**
   * 结算开始时间 比较(endswith)
   */
  private Date settlementStartDateEndswith;
  /**
   * 结算开始时间 比较(isnull)
   */
  private Boolean settlementStartDateIsnull;
  /**
   * 结算开始时间 比较(isnotnull)
   */
  private Boolean settlementStartDateIsnotnull;

  /**
   * 最早结算结束时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementEndDateStart;

  /**
   * 最晚结算结束时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementEndDateEnd;

  /**
   * 结算结束时间 比较(eq)
   */
  private Date settlementEndDateEq;
  /**
   * 结算结束时间 比较(neq)
   */
  private Date settlementEndDateNeq;
  /**
   * 结算结束时间 比较(gt)
   */
  private Date settlementEndDateGt;
  /**
   * 结算结束时间 比较(gte)
   */
  private Date settlementEndDateGte;
  /**
   * 结算结束时间 比较(lt)
   */
  private Date settlementEndDateLt;
  /**
   * 结算结束时间 比较(lte)
   */
  private Date settlementEndDateLte;
  /**
   * 结算结束时间 比较(contains)
   */
  private Date settlementEndDateContains;
  /**
   * 结算结束时间 比较(notcontains)
   */
  private Date settlementEndDateNotcontains;
  /**
   * 结算结束时间 比较(startswith)
   */
  private Date settlementEndDateStartswith;
  /**
   * 结算结束时间 比较(endswith)
   */
  private Date settlementEndDateEndswith;
  /**
   * 结算结束时间 比较(isnull)
   */
  private Boolean settlementEndDateIsnull;
  /**
   * 结算结束时间 比较(isnotnull)
   */
  private Boolean settlementEndDateIsnotnull;

  /**
   * 最早转账日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date fundTransferDateStart;

  /**
   * 最晚转账日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date fundTransferDateEnd;

  /**
   * 转账日期 比较(eq)
   */
  private Date fundTransferDateEq;
  /**
   * 转账日期 比较(neq)
   */
  private Date fundTransferDateNeq;
  /**
   * 转账日期 比较(gt)
   */
  private Date fundTransferDateGt;
  /**
   * 转账日期 比较(gte)
   */
  private Date fundTransferDateGte;
  /**
   * 转账日期 比较(lt)
   */
  private Date fundTransferDateLt;
  /**
   * 转账日期 比较(lte)
   */
  private Date fundTransferDateLte;
  /**
   * 转账日期 比较(contains)
   */
  private Date fundTransferDateContains;
  /**
   * 转账日期 比较(notcontains)
   */
  private Date fundTransferDateNotcontains;
  /**
   * 转账日期 比较(startswith)
   */
  private Date fundTransferDateStartswith;
  /**
   * 转账日期 比较(endswith)
   */
  private Date fundTransferDateEndswith;
  /**
   * 转账日期 比较(isnull)
   */
  private Boolean fundTransferDateIsnull;
  /**
   * 转账日期 比较(isnotnull)
   */
  private Boolean fundTransferDateIsnotnull;

  /**
   * 最早转账日期-当地
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date fundTransferDateLocaleStart;

  /**
   * 最晚转账日期-当地
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date fundTransferDateLocaleEnd;

  /**
   * 转账日期-当地 比较(eq)
   */
  private Date fundTransferDateLocaleEq;
  /**
   * 转账日期-当地 比较(neq)
   */
  private Date fundTransferDateLocaleNeq;
  /**
   * 转账日期-当地 比较(gt)
   */
  private Date fundTransferDateLocaleGt;
  /**
   * 转账日期-当地 比较(gte)
   */
  private Date fundTransferDateLocaleGte;
  /**
   * 转账日期-当地 比较(lt)
   */
  private Date fundTransferDateLocaleLt;
  /**
   * 转账日期-当地 比较(lte)
   */
  private Date fundTransferDateLocaleLte;
  /**
   * 转账日期-当地 比较(contains)
   */
  private Date fundTransferDateLocaleContains;
  /**
   * 转账日期-当地 比较(notcontains)
   */
  private Date fundTransferDateLocaleNotcontains;
  /**
   * 转账日期-当地 比较(startswith)
   */
  private Date fundTransferDateLocaleStartswith;
  /**
   * 转账日期-当地 比较(endswith)
   */
  private Date fundTransferDateLocaleEndswith;
  /**
   * 转账日期-当地 比较(isnull)
   */
  private Boolean fundTransferDateLocaleIsnull;
  /**
   * 转账日期-当地 比较(isnotnull)
   */
  private Boolean fundTransferDateLocaleIsnotnull;

  /**
   * Settlement ID(模糊搜索)
   */
  private String settlementId;

  /**
   * Settlement ID 比较(eq)
   */
  private String settlementIdEq;
  /**
   * Settlement ID 比较(neq)
   */
  private String settlementIdNeq;
  /**
   * Settlement ID 比较(gt)
   */
  private String settlementIdGt;
  /**
   * Settlement ID 比较(gte)
   */
  private String settlementIdGte;
  /**
   * Settlement ID 比较(lt)
   */
  private String settlementIdLt;
  /**
   * Settlement ID 比较(lte)
   */
  private String settlementIdLte;
  /**
   * Settlement ID 比较(contains)
   */
  private String settlementIdContains;
  /**
   * Settlement ID 比较(notcontains)
   */
  private String settlementIdNotcontains;
  /**
   * Settlement ID 比较(startswith)
   */
  private String settlementIdStartswith;
  /**
   * Settlement ID 比较(endswith)
   */
  private String settlementIdEndswith;
  /**
   * Settlement ID 比较(isnull)
   */
  private Boolean settlementIdIsnull;
  /**
   * Settlement ID 比较(isnotnull)
   */
  private Boolean settlementIdIsnotnull;

  /**
   * Settlement ID(精确搜索)
   */
  private List<String> settlementIdInList;

  /**
   * 银行尾号(模糊搜索)
   */
  private String accountTail;

  /**
   * 银行尾号 比较(eq)
   */
  private String accountTailEq;
  /**
   * 银行尾号 比较(neq)
   */
  private String accountTailNeq;
  /**
   * 银行尾号 比较(gt)
   */
  private String accountTailGt;
  /**
   * 银行尾号 比较(gte)
   */
  private String accountTailGte;
  /**
   * 银行尾号 比较(lt)
   */
  private String accountTailLt;
  /**
   * 银行尾号 比较(lte)
   */
  private String accountTailLte;
  /**
   * 银行尾号 比较(contains)
   */
  private String accountTailContains;
  /**
   * 银行尾号 比较(notcontains)
   */
  private String accountTailNotcontains;
  /**
   * 银行尾号 比较(startswith)
   */
  private String accountTailStartswith;
  /**
   * 银行尾号 比较(endswith)
   */
  private String accountTailEndswith;
  /**
   * 银行尾号 比较(isnull)
   */
  private Boolean accountTailIsnull;
  /**
   * 银行尾号 比较(isnotnull)
   */
  private Boolean accountTailIsnotnull;

  /**
   * 银行尾号(精确搜索)
   */
  private List<String> accountTailInList;

  /**
   * 追踪编号(模糊搜索)
   */
  private String traceId;

  /**
   * 追踪编号 比较(eq)
   */
  private String traceIdEq;
  /**
   * 追踪编号 比较(neq)
   */
  private String traceIdNeq;
  /**
   * 追踪编号 比较(gt)
   */
  private String traceIdGt;
  /**
   * 追踪编号 比较(gte)
   */
  private String traceIdGte;
  /**
   * 追踪编号 比较(lt)
   */
  private String traceIdLt;
  /**
   * 追踪编号 比较(lte)
   */
  private String traceIdLte;
  /**
   * 追踪编号 比较(contains)
   */
  private String traceIdContains;
  /**
   * 追踪编号 比较(notcontains)
   */
  private String traceIdNotcontains;
  /**
   * 追踪编号 比较(startswith)
   */
  private String traceIdStartswith;
  /**
   * 追踪编号 比较(endswith)
   */
  private String traceIdEndswith;
  /**
   * 追踪编号 比较(isnull)
   */
  private Boolean traceIdIsnull;
  /**
   * 追踪编号 比较(isnotnull)
   */
  private Boolean traceIdIsnotnull;

  /**
   * 追踪编号(精确搜索)
   */
  private List<String> traceIdInList;

  /**
   * 财务组id(模糊搜索)
   */
  private String financialEventGroupId;

  /**
   * 财务组id 比较(eq)
   */
  private String financialEventGroupIdEq;
  /**
   * 财务组id 比较(neq)
   */
  private String financialEventGroupIdNeq;
  /**
   * 财务组id 比较(gt)
   */
  private String financialEventGroupIdGt;
  /**
   * 财务组id 比较(gte)
   */
  private String financialEventGroupIdGte;
  /**
   * 财务组id 比较(lt)
   */
  private String financialEventGroupIdLt;
  /**
   * 财务组id 比较(lte)
   */
  private String financialEventGroupIdLte;
  /**
   * 财务组id 比较(contains)
   */
  private String financialEventGroupIdContains;
  /**
   * 财务组id 比较(notcontains)
   */
  private String financialEventGroupIdNotcontains;
  /**
   * 财务组id 比较(startswith)
   */
  private String financialEventGroupIdStartswith;
  /**
   * 财务组id 比较(endswith)
   */
  private String financialEventGroupIdEndswith;
  /**
   * 财务组id 比较(isnull)
   */
  private Boolean financialEventGroupIdIsnull;
  /**
   * 财务组id 比较(isnotnull)
   */
  private Boolean financialEventGroupIdIsnotnull;

  /**
   * 财务组id(精确搜索)
   */
  private List<String> financialEventGroupIdInList;

  /**
   * 到账状态
   */
  private String fundTransferGetStatus;

  /**
   * 到账状态 比较(eq)
   */
  private String fundTransferGetStatusEq;
  /**
   * 到账状态 比较(neq)
   */
  private String fundTransferGetStatusNeq;
  /**
   * 到账状态 比较(gt)
   */
  private String fundTransferGetStatusGt;
  /**
   * 到账状态 比较(gte)
   */
  private String fundTransferGetStatusGte;
  /**
   * 到账状态 比较(lt)
   */
  private String fundTransferGetStatusLt;
  /**
   * 到账状态 比较(lte)
   */
  private String fundTransferGetStatusLte;
  /**
   * 到账状态 比较(contains)
   */
  private String fundTransferGetStatusContains;
  /**
   * 到账状态 比较(notcontains)
   */
  private String fundTransferGetStatusNotcontains;
  /**
   * 到账状态 比较(startswith)
   */
  private String fundTransferGetStatusStartswith;
  /**
   * 到账状态 比较(endswith)
   */
  private String fundTransferGetStatusEndswith;
  /**
   * 到账状态 比较(isnull)
   */
  private Boolean fundTransferGetStatusIsnull;
  /**
   * 到账状态 比较(isnotnull)
   */
  private Boolean fundTransferGetStatusIsnotnull;

  /**
   * 到账状态(精确搜索)
   */
  private List<String> fundTransferGetStatusInList;

  /**
   * bucket(模糊搜索)
   */
  private String bucket;

  /**
   * bucket 比较(eq)
   */
  private String bucketEq;
  /**
   * bucket 比较(neq)
   */
  private String bucketNeq;
  /**
   * bucket 比较(gt)
   */
  private String bucketGt;
  /**
   * bucket 比较(gte)
   */
  private String bucketGte;
  /**
   * bucket 比较(lt)
   */
  private String bucketLt;
  /**
   * bucket 比较(lte)
   */
  private String bucketLte;
  /**
   * bucket 比较(contains)
   */
  private String bucketContains;
  /**
   * bucket 比较(notcontains)
   */
  private String bucketNotcontains;
  /**
   * bucket 比较(startswith)
   */
  private String bucketStartswith;
  /**
   * bucket 比较(endswith)
   */
  private String bucketEndswith;
  /**
   * bucket 比较(isnull)
   */
  private Boolean bucketIsnull;
  /**
   * bucket 比较(isnotnull)
   */
  private Boolean bucketIsnotnull;

  /**
   * bucket(精确搜索)
   */
  private List<String> bucketInList;

  /**
   * s3FileKey(模糊搜索)
   */
  private String s3FileKey;

  /**
   * s3FileKey 比较(eq)
   */
  private String s3FileKeyEq;
  /**
   * s3FileKey 比较(neq)
   */
  private String s3FileKeyNeq;
  /**
   * s3FileKey 比较(gt)
   */
  private String s3FileKeyGt;
  /**
   * s3FileKey 比较(gte)
   */
  private String s3FileKeyGte;
  /**
   * s3FileKey 比较(lt)
   */
  private String s3FileKeyLt;
  /**
   * s3FileKey 比较(lte)
   */
  private String s3FileKeyLte;
  /**
   * s3FileKey 比较(contains)
   */
  private String s3FileKeyContains;
  /**
   * s3FileKey 比较(notcontains)
   */
  private String s3FileKeyNotcontains;
  /**
   * s3FileKey 比较(startswith)
   */
  private String s3FileKeyStartswith;
  /**
   * s3FileKey 比较(endswith)
   */
  private String s3FileKeyEndswith;
  /**
   * s3FileKey 比较(isnull)
   */
  private Boolean s3FileKeyIsnull;
  /**
   * s3FileKey 比较(isnotnull)
   */
  private Boolean s3FileKeyIsnotnull;

  /**
   * s3FileKey(精确搜索)
   */
  private List<String> s3FileKeyInList;

  /**
   * 应收币种符号(模糊搜索)
   */
  private String originCurrencyIcon;

  /**
   * 应收币种符号 比较(eq)
   */
  private String originCurrencyIconEq;
  /**
   * 应收币种符号 比较(neq)
   */
  private String originCurrencyIconNeq;
  /**
   * 应收币种符号 比较(gt)
   */
  private String originCurrencyIconGt;
  /**
   * 应收币种符号 比较(gte)
   */
  private String originCurrencyIconGte;
  /**
   * 应收币种符号 比较(lt)
   */
  private String originCurrencyIconLt;
  /**
   * 应收币种符号 比较(lte)
   */
  private String originCurrencyIconLte;
  /**
   * 应收币种符号 比较(contains)
   */
  private String originCurrencyIconContains;
  /**
   * 应收币种符号 比较(notcontains)
   */
  private String originCurrencyIconNotcontains;
  /**
   * 应收币种符号 比较(startswith)
   */
  private String originCurrencyIconStartswith;
  /**
   * 应收币种符号 比较(endswith)
   */
  private String originCurrencyIconEndswith;
  /**
   * 应收币种符号 比较(isnull)
   */
  private Boolean originCurrencyIconIsnull;
  /**
   * 应收币种符号 比较(isnotnull)
   */
  private Boolean originCurrencyIconIsnotnull;

  /**
   * 应收币种符号(精确搜索)
   */
  private List<String> originCurrencyIconInList;

  /**
   * 转账币种符号(模糊搜索)
   */
  private String convertCurrencyIcon;

  /**
   * 转账币种符号 比较(eq)
   */
  private String convertCurrencyIconEq;
  /**
   * 转账币种符号 比较(neq)
   */
  private String convertCurrencyIconNeq;
  /**
   * 转账币种符号 比较(gt)
   */
  private String convertCurrencyIconGt;
  /**
   * 转账币种符号 比较(gte)
   */
  private String convertCurrencyIconGte;
  /**
   * 转账币种符号 比较(lt)
   */
  private String convertCurrencyIconLt;
  /**
   * 转账币种符号 比较(lte)
   */
  private String convertCurrencyIconLte;
  /**
   * 转账币种符号 比较(contains)
   */
  private String convertCurrencyIconContains;
  /**
   * 转账币种符号 比较(notcontains)
   */
  private String convertCurrencyIconNotcontains;
  /**
   * 转账币种符号 比较(startswith)
   */
  private String convertCurrencyIconStartswith;
  /**
   * 转账币种符号 比较(endswith)
   */
  private String convertCurrencyIconEndswith;
  /**
   * 转账币种符号 比较(isnull)
   */
  private Boolean convertCurrencyIconIsnull;
  /**
   * 转账币种符号 比较(isnotnull)
   */
  private Boolean convertCurrencyIconIsnotnull;

  /**
   * 转账币种符号(精确搜索)
   */
  private List<String> convertCurrencyIconInList;

  /**
   * 回款率
   */
  private java.math.BigDecimal collectionRate;

  /**
   * 最小回款率
   */
  private java.math.BigDecimal collectionRateMin;

  /**
   * 最大回款率
   */
  private java.math.BigDecimal collectionRateMax;

  /**
   * 回款率 比较(eq)
   */
  private java.math.BigDecimal collectionRateEq;
  /**
   * 回款率 比较(neq)
   */
  private java.math.BigDecimal collectionRateNeq;
  /**
   * 回款率 比较(gt)
   */
  private java.math.BigDecimal collectionRateGt;
  /**
   * 回款率 比较(gte)
   */
  private java.math.BigDecimal collectionRateGte;
  /**
   * 回款率 比较(lt)
   */
  private java.math.BigDecimal collectionRateLt;
  /**
   * 回款率 比较(lte)
   */
  private java.math.BigDecimal collectionRateLte;
  /**
   * 回款率 比较(contains)
   */
  private java.math.BigDecimal collectionRateContains;
  /**
   * 回款率 比较(notcontains)
   */
  private java.math.BigDecimal collectionRateNotcontains;
  /**
   * 回款率 比较(startswith)
   */
  private java.math.BigDecimal collectionRateStartswith;
  /**
   * 回款率 比较(endswith)
   */
  private java.math.BigDecimal collectionRateEndswith;
  /**
   * 回款率 比较(isnull)
   */
  private Boolean collectionRateIsnull;
  /**
   * 回款率 比较(isnotnull)
   */
  private Boolean collectionRateIsnotnull;

  /**
   * 收入
   */
  private java.math.BigDecimal sale;

  /**
   * 最小收入
   */
  private java.math.BigDecimal saleMin;

  /**
   * 最大收入
   */
  private java.math.BigDecimal saleMax;

  /**
   * 收入 比较(eq)
   */
  private java.math.BigDecimal saleEq;
  /**
   * 收入 比较(neq)
   */
  private java.math.BigDecimal saleNeq;
  /**
   * 收入 比较(gt)
   */
  private java.math.BigDecimal saleGt;
  /**
   * 收入 比较(gte)
   */
  private java.math.BigDecimal saleGte;
  /**
   * 收入 比较(lt)
   */
  private java.math.BigDecimal saleLt;
  /**
   * 收入 比较(lte)
   */
  private java.math.BigDecimal saleLte;
  /**
   * 收入 比较(contains)
   */
  private java.math.BigDecimal saleContains;
  /**
   * 收入 比较(notcontains)
   */
  private java.math.BigDecimal saleNotcontains;
  /**
   * 收入 比较(startswith)
   */
  private java.math.BigDecimal saleStartswith;
  /**
   * 收入 比较(endswith)
   */
  private java.math.BigDecimal saleEndswith;
  /**
   * 收入 比较(isnull)
   */
  private Boolean saleIsnull;
  /**
   * 收入 比较(isnotnull)
   */
  private Boolean saleIsnotnull;

  /**
   * 产品销售
   */
  private java.math.BigDecimal saleProduct;

  /**
   * 最小产品销售
   */
  private java.math.BigDecimal saleProductMin;

  /**
   * 最大产品销售
   */
  private java.math.BigDecimal saleProductMax;

  /**
   * 产品销售 比较(eq)
   */
  private java.math.BigDecimal saleProductEq;
  /**
   * 产品销售 比较(neq)
   */
  private java.math.BigDecimal saleProductNeq;
  /**
   * 产品销售 比较(gt)
   */
  private java.math.BigDecimal saleProductGt;
  /**
   * 产品销售 比较(gte)
   */
  private java.math.BigDecimal saleProductGte;
  /**
   * 产品销售 比较(lt)
   */
  private java.math.BigDecimal saleProductLt;
  /**
   * 产品销售 比较(lte)
   */
  private java.math.BigDecimal saleProductLte;
  /**
   * 产品销售 比较(contains)
   */
  private java.math.BigDecimal saleProductContains;
  /**
   * 产品销售 比较(notcontains)
   */
  private java.math.BigDecimal saleProductNotcontains;
  /**
   * 产品销售 比较(startswith)
   */
  private java.math.BigDecimal saleProductStartswith;
  /**
   * 产品销售 比较(endswith)
   */
  private java.math.BigDecimal saleProductEndswith;
  /**
   * 产品销售 比较(isnull)
   */
  private Boolean saleProductIsnull;
  /**
   * 产品销售 比较(isnotnull)
   */
  private Boolean saleProductIsnotnull;

  /**
   * 买家运费
   */
  private java.math.BigDecimal saleFreight;

  /**
   * 最小买家运费
   */
  private java.math.BigDecimal saleFreightMin;

  /**
   * 最大买家运费
   */
  private java.math.BigDecimal saleFreightMax;

  /**
   * 买家运费 比较(eq)
   */
  private java.math.BigDecimal saleFreightEq;
  /**
   * 买家运费 比较(neq)
   */
  private java.math.BigDecimal saleFreightNeq;
  /**
   * 买家运费 比较(gt)
   */
  private java.math.BigDecimal saleFreightGt;
  /**
   * 买家运费 比较(gte)
   */
  private java.math.BigDecimal saleFreightGte;
  /**
   * 买家运费 比较(lt)
   */
  private java.math.BigDecimal saleFreightLt;
  /**
   * 买家运费 比较(lte)
   */
  private java.math.BigDecimal saleFreightLte;
  /**
   * 买家运费 比较(contains)
   */
  private java.math.BigDecimal saleFreightContains;
  /**
   * 买家运费 比较(notcontains)
   */
  private java.math.BigDecimal saleFreightNotcontains;
  /**
   * 买家运费 比较(startswith)
   */
  private java.math.BigDecimal saleFreightStartswith;
  /**
   * 买家运费 比较(endswith)
   */
  private java.math.BigDecimal saleFreightEndswith;
  /**
   * 买家运费 比较(isnull)
   */
  private Boolean saleFreightIsnull;
  /**
   * 买家运费 比较(isnotnull)
   */
  private Boolean saleFreightIsnotnull;

  /**
   * 包装
   */
  private java.math.BigDecimal salePacking;

  /**
   * 最小包装
   */
  private java.math.BigDecimal salePackingMin;

  /**
   * 最大包装
   */
  private java.math.BigDecimal salePackingMax;

  /**
   * 包装 比较(eq)
   */
  private java.math.BigDecimal salePackingEq;
  /**
   * 包装 比较(neq)
   */
  private java.math.BigDecimal salePackingNeq;
  /**
   * 包装 比较(gt)
   */
  private java.math.BigDecimal salePackingGt;
  /**
   * 包装 比较(gte)
   */
  private java.math.BigDecimal salePackingGte;
  /**
   * 包装 比较(lt)
   */
  private java.math.BigDecimal salePackingLt;
  /**
   * 包装 比较(lte)
   */
  private java.math.BigDecimal salePackingLte;
  /**
   * 包装 比较(contains)
   */
  private java.math.BigDecimal salePackingContains;
  /**
   * 包装 比较(notcontains)
   */
  private java.math.BigDecimal salePackingNotcontains;
  /**
   * 包装 比较(startswith)
   */
  private java.math.BigDecimal salePackingStartswith;
  /**
   * 包装 比较(endswith)
   */
  private java.math.BigDecimal salePackingEndswith;
  /**
   * 包装 比较(isnull)
   */
  private Boolean salePackingIsnull;
  /**
   * 包装 比较(isnotnull)
   */
  private Boolean salePackingIsnotnull;

  /**
   * 其他
   */
  private java.math.BigDecimal saleOther;

  /**
   * 最小其他
   */
  private java.math.BigDecimal saleOtherMin;

  /**
   * 最大其他
   */
  private java.math.BigDecimal saleOtherMax;

  /**
   * 其他 比较(eq)
   */
  private java.math.BigDecimal saleOtherEq;
  /**
   * 其他 比较(neq)
   */
  private java.math.BigDecimal saleOtherNeq;
  /**
   * 其他 比较(gt)
   */
  private java.math.BigDecimal saleOtherGt;
  /**
   * 其他 比较(gte)
   */
  private java.math.BigDecimal saleOtherGte;
  /**
   * 其他 比较(lt)
   */
  private java.math.BigDecimal saleOtherLt;
  /**
   * 其他 比较(lte)
   */
  private java.math.BigDecimal saleOtherLte;
  /**
   * 其他 比较(contains)
   */
  private java.math.BigDecimal saleOtherContains;
  /**
   * 其他 比较(notcontains)
   */
  private java.math.BigDecimal saleOtherNotcontains;
  /**
   * 其他 比较(startswith)
   */
  private java.math.BigDecimal saleOtherStartswith;
  /**
   * 其他 比较(endswith)
   */
  private java.math.BigDecimal saleOtherEndswith;
  /**
   * 其他 比较(isnull)
   */
  private Boolean saleOtherIsnull;
  /**
   * 其他 比较(isnotnull)
   */
  private Boolean saleOtherIsnotnull;

  /**
   * 税
   */
  private java.math.BigDecimal saleTax;

  /**
   * 最小税
   */
  private java.math.BigDecimal saleTaxMin;

  /**
   * 最大税
   */
  private java.math.BigDecimal saleTaxMax;

  /**
   * 税 比较(eq)
   */
  private java.math.BigDecimal saleTaxEq;
  /**
   * 税 比较(neq)
   */
  private java.math.BigDecimal saleTaxNeq;
  /**
   * 税 比较(gt)
   */
  private java.math.BigDecimal saleTaxGt;
  /**
   * 税 比较(gte)
   */
  private java.math.BigDecimal saleTaxGte;
  /**
   * 税 比较(lt)
   */
  private java.math.BigDecimal saleTaxLt;
  /**
   * 税 比较(lte)
   */
  private java.math.BigDecimal saleTaxLte;
  /**
   * 税 比较(contains)
   */
  private java.math.BigDecimal saleTaxContains;
  /**
   * 税 比较(notcontains)
   */
  private java.math.BigDecimal saleTaxNotcontains;
  /**
   * 税 比较(startswith)
   */
  private java.math.BigDecimal saleTaxStartswith;
  /**
   * 税 比较(endswith)
   */
  private java.math.BigDecimal saleTaxEndswith;
  /**
   * 税 比较(isnull)
   */
  private Boolean saleTaxIsnull;
  /**
   * 税 比较(isnotnull)
   */
  private Boolean saleTaxIsnotnull;

  /**
   * 应收金额
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmount;

  /**
   * 最小应收金额
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountMin;

  /**
   * 最大应收金额
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountMax;

  /**
   * 应收金额 比较(eq)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountEq;
  /**
   * 应收金额 比较(neq)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountNeq;
  /**
   * 应收金额 比较(gt)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountGt;
  /**
   * 应收金额 比较(gte)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountGte;
  /**
   * 应收金额 比较(lt)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountLt;
  /**
   * 应收金额 比较(lte)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountLte;
  /**
   * 应收金额 比较(contains)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountContains;
  /**
   * 应收金额 比较(notcontains)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountNotcontains;
  /**
   * 应收金额 比较(startswith)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountStartswith;
  /**
   * 应收金额 比较(endswith)
   */
  private java.math.BigDecimal transferConvertedTotalCurrencyAmountEndswith;
  /**
   * 应收金额 比较(isnull)
   */
  private Boolean transferConvertedTotalCurrencyAmountIsnull;
  /**
   * 应收金额 比较(isnotnull)
   */
  private Boolean transferConvertedTotalCurrencyAmountIsnotnull;

  /**
   * 期初余额
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmount;

  /**
   * 最小期初余额
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountMin;

  /**
   * 最大期初余额
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountMax;

  /**
   * 期初余额 比较(eq)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountEq;
  /**
   * 期初余额 比较(neq)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountNeq;
  /**
   * 期初余额 比较(gt)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountGt;
  /**
   * 期初余额 比较(gte)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountGte;
  /**
   * 期初余额 比较(lt)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountLt;
  /**
   * 期初余额 比较(lte)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountLte;
  /**
   * 期初余额 比较(contains)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountContains;
  /**
   * 期初余额 比较(notcontains)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountNotcontains;
  /**
   * 期初余额 比较(startswith)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountStartswith;
  /**
   * 期初余额 比较(endswith)
   */
  private java.math.BigDecimal transferBeginningBalanceCurrencyAmountEndswith;
  /**
   * 期初余额 比较(isnull)
   */
  private Boolean transferBeginningBalanceCurrencyAmountIsnull;
  /**
   * 期初余额 比较(isnotnull)
   */
  private Boolean transferBeginningBalanceCurrencyAmountIsnotnull;

  /**
   * 本期结算
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmount;

  /**
   * 最小本期结算
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountMin;

  /**
   * 最大本期结算
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountMax;

  /**
   * 本期结算 比较(eq)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountEq;
  /**
   * 本期结算 比较(neq)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountNeq;
  /**
   * 本期结算 比较(gt)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountGt;
  /**
   * 本期结算 比较(gte)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountGte;
  /**
   * 本期结算 比较(lt)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountLt;
  /**
   * 本期结算 比较(lte)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountLte;
  /**
   * 本期结算 比较(contains)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountContains;
  /**
   * 本期结算 比较(notcontains)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountNotcontains;
  /**
   * 本期结算 比较(startswith)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountStartswith;
  /**
   * 本期结算 比较(endswith)
   */
  private java.math.BigDecimal transferOriginalTotalCurrencyAmountEndswith;
  /**
   * 本期结算 比较(isnull)
   */
  private Boolean transferOriginalTotalCurrencyAmountIsnull;
  /**
   * 本期结算 比较(isnotnull)
   */
  private Boolean transferOriginalTotalCurrencyAmountIsnotnull;

  /**
   * 预留退回
   */
  private java.math.BigDecimal transferPreviousReserveAmount;

  /**
   * 最小预留退回
   */
  private java.math.BigDecimal transferPreviousReserveAmountMin;

  /**
   * 最大预留退回
   */
  private java.math.BigDecimal transferPreviousReserveAmountMax;

  /**
   * 预留退回 比较(eq)
   */
  private java.math.BigDecimal transferPreviousReserveAmountEq;
  /**
   * 预留退回 比较(neq)
   */
  private java.math.BigDecimal transferPreviousReserveAmountNeq;
  /**
   * 预留退回 比较(gt)
   */
  private java.math.BigDecimal transferPreviousReserveAmountGt;
  /**
   * 预留退回 比较(gte)
   */
  private java.math.BigDecimal transferPreviousReserveAmountGte;
  /**
   * 预留退回 比较(lt)
   */
  private java.math.BigDecimal transferPreviousReserveAmountLt;
  /**
   * 预留退回 比较(lte)
   */
  private java.math.BigDecimal transferPreviousReserveAmountLte;
  /**
   * 预留退回 比较(contains)
   */
  private java.math.BigDecimal transferPreviousReserveAmountContains;
  /**
   * 预留退回 比较(notcontains)
   */
  private java.math.BigDecimal transferPreviousReserveAmountNotcontains;
  /**
   * 预留退回 比较(startswith)
   */
  private java.math.BigDecimal transferPreviousReserveAmountStartswith;
  /**
   * 预留退回 比较(endswith)
   */
  private java.math.BigDecimal transferPreviousReserveAmountEndswith;
  /**
   * 预留退回 比较(isnull)
   */
  private Boolean transferPreviousReserveAmountIsnull;
  /**
   * 预留退回 比较(isnotnull)
   */
  private Boolean transferPreviousReserveAmountIsnotnull;

  /**
   * 本期预留
   */
  private java.math.BigDecimal transferCurrentReserveAmount;

  /**
   * 最小本期预留
   */
  private java.math.BigDecimal transferCurrentReserveAmountMin;

  /**
   * 最大本期预留
   */
  private java.math.BigDecimal transferCurrentReserveAmountMax;

  /**
   * 本期预留 比较(eq)
   */
  private java.math.BigDecimal transferCurrentReserveAmountEq;
  /**
   * 本期预留 比较(neq)
   */
  private java.math.BigDecimal transferCurrentReserveAmountNeq;
  /**
   * 本期预留 比较(gt)
   */
  private java.math.BigDecimal transferCurrentReserveAmountGt;
  /**
   * 本期预留 比较(gte)
   */
  private java.math.BigDecimal transferCurrentReserveAmountGte;
  /**
   * 本期预留 比较(lt)
   */
  private java.math.BigDecimal transferCurrentReserveAmountLt;
  /**
   * 本期预留 比较(lte)
   */
  private java.math.BigDecimal transferCurrentReserveAmountLte;
  /**
   * 本期预留 比较(contains)
   */
  private java.math.BigDecimal transferCurrentReserveAmountContains;
  /**
   * 本期预留 比较(notcontains)
   */
  private java.math.BigDecimal transferCurrentReserveAmountNotcontains;
  /**
   * 本期预留 比较(startswith)
   */
  private java.math.BigDecimal transferCurrentReserveAmountStartswith;
  /**
   * 本期预留 比较(endswith)
   */
  private java.math.BigDecimal transferCurrentReserveAmountEndswith;
  /**
   * 本期预留 比较(isnull)
   */
  private Boolean transferCurrentReserveAmountIsnull;
  /**
   * 本期预留 比较(isnotnull)
   */
  private Boolean transferCurrentReserveAmountIsnotnull;

  /**
   * 信用卡扣款
   */
  private java.math.BigDecimal transferCreditCardDeduction;

  /**
   * 最小信用卡扣款
   */
  private java.math.BigDecimal transferCreditCardDeductionMin;

  /**
   * 最大信用卡扣款
   */
  private java.math.BigDecimal transferCreditCardDeductionMax;

  /**
   * 信用卡扣款 比较(eq)
   */
  private java.math.BigDecimal transferCreditCardDeductionEq;
  /**
   * 信用卡扣款 比较(neq)
   */
  private java.math.BigDecimal transferCreditCardDeductionNeq;
  /**
   * 信用卡扣款 比较(gt)
   */
  private java.math.BigDecimal transferCreditCardDeductionGt;
  /**
   * 信用卡扣款 比较(gte)
   */
  private java.math.BigDecimal transferCreditCardDeductionGte;
  /**
   * 信用卡扣款 比较(lt)
   */
  private java.math.BigDecimal transferCreditCardDeductionLt;
  /**
   * 信用卡扣款 比较(lte)
   */
  private java.math.BigDecimal transferCreditCardDeductionLte;
  /**
   * 信用卡扣款 比较(contains)
   */
  private java.math.BigDecimal transferCreditCardDeductionContains;
  /**
   * 信用卡扣款 比较(notcontains)
   */
  private java.math.BigDecimal transferCreditCardDeductionNotcontains;
  /**
   * 信用卡扣款 比较(startswith)
   */
  private java.math.BigDecimal transferCreditCardDeductionStartswith;
  /**
   * 信用卡扣款 比较(endswith)
   */
  private java.math.BigDecimal transferCreditCardDeductionEndswith;
  /**
   * 信用卡扣款 比较(isnull)
   */
  private Boolean transferCreditCardDeductionIsnull;
  /**
   * 信用卡扣款 比较(isnotnull)
   */
  private Boolean transferCreditCardDeductionIsnotnull;

  /**
   * 退款
   */
  private java.math.BigDecimal refund;

  /**
   * 最小退款
   */
  private java.math.BigDecimal refundMin;

  /**
   * 最大退款
   */
  private java.math.BigDecimal refundMax;

  /**
   * 退款 比较(eq)
   */
  private java.math.BigDecimal refundEq;
  /**
   * 退款 比较(neq)
   */
  private java.math.BigDecimal refundNeq;
  /**
   * 退款 比较(gt)
   */
  private java.math.BigDecimal refundGt;
  /**
   * 退款 比较(gte)
   */
  private java.math.BigDecimal refundGte;
  /**
   * 退款 比较(lt)
   */
  private java.math.BigDecimal refundLt;
  /**
   * 退款 比较(lte)
   */
  private java.math.BigDecimal refundLte;
  /**
   * 退款 比较(contains)
   */
  private java.math.BigDecimal refundContains;
  /**
   * 退款 比较(notcontains)
   */
  private java.math.BigDecimal refundNotcontains;
  /**
   * 退款 比较(startswith)
   */
  private java.math.BigDecimal refundStartswith;
  /**
   * 退款 比较(endswith)
   */
  private java.math.BigDecimal refundEndswith;
  /**
   * 退款 比较(isnull)
   */
  private Boolean refundIsnull;
  /**
   * 退款 比较(isnotnull)
   */
  private Boolean refundIsnotnull;

  /**
   * 收入退款
   */
  private java.math.BigDecimal refundSaleRefund;

  /**
   * 最小收入退款
   */
  private java.math.BigDecimal refundSaleRefundMin;

  /**
   * 最大收入退款
   */
  private java.math.BigDecimal refundSaleRefundMax;

  /**
   * 收入退款 比较(eq)
   */
  private java.math.BigDecimal refundSaleRefundEq;
  /**
   * 收入退款 比较(neq)
   */
  private java.math.BigDecimal refundSaleRefundNeq;
  /**
   * 收入退款 比较(gt)
   */
  private java.math.BigDecimal refundSaleRefundGt;
  /**
   * 收入退款 比较(gte)
   */
  private java.math.BigDecimal refundSaleRefundGte;
  /**
   * 收入退款 比较(lt)
   */
  private java.math.BigDecimal refundSaleRefundLt;
  /**
   * 收入退款 比较(lte)
   */
  private java.math.BigDecimal refundSaleRefundLte;
  /**
   * 收入退款 比较(contains)
   */
  private java.math.BigDecimal refundSaleRefundContains;
  /**
   * 收入退款 比较(notcontains)
   */
  private java.math.BigDecimal refundSaleRefundNotcontains;
  /**
   * 收入退款 比较(startswith)
   */
  private java.math.BigDecimal refundSaleRefundStartswith;
  /**
   * 收入退款 比较(endswith)
   */
  private java.math.BigDecimal refundSaleRefundEndswith;
  /**
   * 收入退款 比较(isnull)
   */
  private Boolean refundSaleRefundIsnull;
  /**
   * 收入退款 比较(isnotnull)
   */
  private Boolean refundSaleRefundIsnotnull;

  /**
   * 费用退款
   */
  private java.math.BigDecimal refundFeeRefund;

  /**
   * 最小费用退款
   */
  private java.math.BigDecimal refundFeeRefundMin;

  /**
   * 最大费用退款
   */
  private java.math.BigDecimal refundFeeRefundMax;

  /**
   * 费用退款 比较(eq)
   */
  private java.math.BigDecimal refundFeeRefundEq;
  /**
   * 费用退款 比较(neq)
   */
  private java.math.BigDecimal refundFeeRefundNeq;
  /**
   * 费用退款 比较(gt)
   */
  private java.math.BigDecimal refundFeeRefundGt;
  /**
   * 费用退款 比较(gte)
   */
  private java.math.BigDecimal refundFeeRefundGte;
  /**
   * 费用退款 比较(lt)
   */
  private java.math.BigDecimal refundFeeRefundLt;
  /**
   * 费用退款 比较(lte)
   */
  private java.math.BigDecimal refundFeeRefundLte;
  /**
   * 费用退款 比较(contains)
   */
  private java.math.BigDecimal refundFeeRefundContains;
  /**
   * 费用退款 比较(notcontains)
   */
  private java.math.BigDecimal refundFeeRefundNotcontains;
  /**
   * 费用退款 比较(startswith)
   */
  private java.math.BigDecimal refundFeeRefundStartswith;
  /**
   * 费用退款 比较(endswith)
   */
  private java.math.BigDecimal refundFeeRefundEndswith;
  /**
   * 费用退款 比较(isnull)
   */
  private Boolean refundFeeRefundIsnull;
  /**
   * 费用退款 比较(isnotnull)
   */
  private Boolean refundFeeRefundIsnotnull;

  /**
   * 税退款
   */
  private java.math.BigDecimal refundTax;

  /**
   * 最小税退款
   */
  private java.math.BigDecimal refundTaxMin;

  /**
   * 最大税退款
   */
  private java.math.BigDecimal refundTaxMax;

  /**
   * 税退款 比较(eq)
   */
  private java.math.BigDecimal refundTaxEq;
  /**
   * 税退款 比较(neq)
   */
  private java.math.BigDecimal refundTaxNeq;
  /**
   * 税退款 比较(gt)
   */
  private java.math.BigDecimal refundTaxGt;
  /**
   * 税退款 比较(gte)
   */
  private java.math.BigDecimal refundTaxGte;
  /**
   * 税退款 比较(lt)
   */
  private java.math.BigDecimal refundTaxLt;
  /**
   * 税退款 比较(lte)
   */
  private java.math.BigDecimal refundTaxLte;
  /**
   * 税退款 比较(contains)
   */
  private java.math.BigDecimal refundTaxContains;
  /**
   * 税退款 比较(notcontains)
   */
  private java.math.BigDecimal refundTaxNotcontains;
  /**
   * 税退款 比较(startswith)
   */
  private java.math.BigDecimal refundTaxStartswith;
  /**
   * 税退款 比较(endswith)
   */
  private java.math.BigDecimal refundTaxEndswith;
  /**
   * 税退款 比较(isnull)
   */
  private Boolean refundTaxIsnull;
  /**
   * 税退款 比较(isnotnull)
   */
  private Boolean refundTaxIsnotnull;

  /**
   * 支出
   */
  private java.math.BigDecimal pay;

  /**
   * 最小支出
   */
  private java.math.BigDecimal payMin;

  /**
   * 最大支出
   */
  private java.math.BigDecimal payMax;

  /**
   * 支出 比较(eq)
   */
  private java.math.BigDecimal payEq;
  /**
   * 支出 比较(neq)
   */
  private java.math.BigDecimal payNeq;
  /**
   * 支出 比较(gt)
   */
  private java.math.BigDecimal payGt;
  /**
   * 支出 比较(gte)
   */
  private java.math.BigDecimal payGte;
  /**
   * 支出 比较(lt)
   */
  private java.math.BigDecimal payLt;
  /**
   * 支出 比较(lte)
   */
  private java.math.BigDecimal payLte;
  /**
   * 支出 比较(contains)
   */
  private java.math.BigDecimal payContains;
  /**
   * 支出 比较(notcontains)
   */
  private java.math.BigDecimal payNotcontains;
  /**
   * 支出 比较(startswith)
   */
  private java.math.BigDecimal payStartswith;
  /**
   * 支出 比较(endswith)
   */
  private java.math.BigDecimal payEndswith;
  /**
   * 支出 比较(isnull)
   */
  private Boolean payIsnull;
  /**
   * 支出 比较(isnotnull)
   */
  private Boolean payIsnotnull;

  /**
   * 仓储费用
   */
  private java.math.BigDecimal payStorage;

  /**
   * 最小仓储费用
   */
  private java.math.BigDecimal payStorageMin;

  /**
   * 最大仓储费用
   */
  private java.math.BigDecimal payStorageMax;

  /**
   * 仓储费用 比较(eq)
   */
  private java.math.BigDecimal payStorageEq;
  /**
   * 仓储费用 比较(neq)
   */
  private java.math.BigDecimal payStorageNeq;
  /**
   * 仓储费用 比较(gt)
   */
  private java.math.BigDecimal payStorageGt;
  /**
   * 仓储费用 比较(gte)
   */
  private java.math.BigDecimal payStorageGte;
  /**
   * 仓储费用 比较(lt)
   */
  private java.math.BigDecimal payStorageLt;
  /**
   * 仓储费用 比较(lte)
   */
  private java.math.BigDecimal payStorageLte;
  /**
   * 仓储费用 比较(contains)
   */
  private java.math.BigDecimal payStorageContains;
  /**
   * 仓储费用 比较(notcontains)
   */
  private java.math.BigDecimal payStorageNotcontains;
  /**
   * 仓储费用 比较(startswith)
   */
  private java.math.BigDecimal payStorageStartswith;
  /**
   * 仓储费用 比较(endswith)
   */
  private java.math.BigDecimal payStorageEndswith;
  /**
   * 仓储费用 比较(isnull)
   */
  private Boolean payStorageIsnull;
  /**
   * 仓储费用 比较(isnotnull)
   */
  private Boolean payStorageIsnotnull;

  /**
   * 亚马逊费用
   */
  private java.math.BigDecimal payAmazon;

  /**
   * 最小亚马逊费用
   */
  private java.math.BigDecimal payAmazonMin;

  /**
   * 最大亚马逊费用
   */
  private java.math.BigDecimal payAmazonMax;

  /**
   * 亚马逊费用 比较(eq)
   */
  private java.math.BigDecimal payAmazonEq;
  /**
   * 亚马逊费用 比较(neq)
   */
  private java.math.BigDecimal payAmazonNeq;
  /**
   * 亚马逊费用 比较(gt)
   */
  private java.math.BigDecimal payAmazonGt;
  /**
   * 亚马逊费用 比较(gte)
   */
  private java.math.BigDecimal payAmazonGte;
  /**
   * 亚马逊费用 比较(lt)
   */
  private java.math.BigDecimal payAmazonLt;
  /**
   * 亚马逊费用 比较(lte)
   */
  private java.math.BigDecimal payAmazonLte;
  /**
   * 亚马逊费用 比较(contains)
   */
  private java.math.BigDecimal payAmazonContains;
  /**
   * 亚马逊费用 比较(notcontains)
   */
  private java.math.BigDecimal payAmazonNotcontains;
  /**
   * 亚马逊费用 比较(startswith)
   */
  private java.math.BigDecimal payAmazonStartswith;
  /**
   * 亚马逊费用 比较(endswith)
   */
  private java.math.BigDecimal payAmazonEndswith;
  /**
   * 亚马逊费用 比较(isnull)
   */
  private Boolean payAmazonIsnull;
  /**
   * 亚马逊费用 比较(isnotnull)
   */
  private Boolean payAmazonIsnotnull;

  /**
   * 广告费
   */
  private java.math.BigDecimal payAd;

  /**
   * 最小广告费
   */
  private java.math.BigDecimal payAdMin;

  /**
   * 最大广告费
   */
  private java.math.BigDecimal payAdMax;

  /**
   * 广告费 比较(eq)
   */
  private java.math.BigDecimal payAdEq;
  /**
   * 广告费 比较(neq)
   */
  private java.math.BigDecimal payAdNeq;
  /**
   * 广告费 比较(gt)
   */
  private java.math.BigDecimal payAdGt;
  /**
   * 广告费 比较(gte)
   */
  private java.math.BigDecimal payAdGte;
  /**
   * 广告费 比较(lt)
   */
  private java.math.BigDecimal payAdLt;
  /**
   * 广告费 比较(lte)
   */
  private java.math.BigDecimal payAdLte;
  /**
   * 广告费 比较(contains)
   */
  private java.math.BigDecimal payAdContains;
  /**
   * 广告费 比较(notcontains)
   */
  private java.math.BigDecimal payAdNotcontains;
  /**
   * 广告费 比较(startswith)
   */
  private java.math.BigDecimal payAdStartswith;
  /**
   * 广告费 比较(endswith)
   */
  private java.math.BigDecimal payAdEndswith;
  /**
   * 广告费 比较(isnull)
   */
  private Boolean payAdIsnull;
  /**
   * 广告费 比较(isnotnull)
   */
  private Boolean payAdIsnotnull;

  /**
   * 促销费
   */
  private java.math.BigDecimal payPromotion;

  /**
   * 最小促销费
   */
  private java.math.BigDecimal payPromotionMin;

  /**
   * 最大促销费
   */
  private java.math.BigDecimal payPromotionMax;

  /**
   * 促销费 比较(eq)
   */
  private java.math.BigDecimal payPromotionEq;
  /**
   * 促销费 比较(neq)
   */
  private java.math.BigDecimal payPromotionNeq;
  /**
   * 促销费 比较(gt)
   */
  private java.math.BigDecimal payPromotionGt;
  /**
   * 促销费 比较(gte)
   */
  private java.math.BigDecimal payPromotionGte;
  /**
   * 促销费 比较(lt)
   */
  private java.math.BigDecimal payPromotionLt;
  /**
   * 促销费 比较(lte)
   */
  private java.math.BigDecimal payPromotionLte;
  /**
   * 促销费 比较(contains)
   */
  private java.math.BigDecimal payPromotionContains;
  /**
   * 促销费 比较(notcontains)
   */
  private java.math.BigDecimal payPromotionNotcontains;
  /**
   * 促销费 比较(startswith)
   */
  private java.math.BigDecimal payPromotionStartswith;
  /**
   * 促销费 比较(endswith)
   */
  private java.math.BigDecimal payPromotionEndswith;
  /**
   * 促销费 比较(isnull)
   */
  private Boolean payPromotionIsnull;
  /**
   * 促销费 比较(isnotnull)
   */
  private Boolean payPromotionIsnotnull;

  /**
   * 其他
   */
  private java.math.BigDecimal payOther;

  /**
   * 最小其他
   */
  private java.math.BigDecimal payOtherMin;

  /**
   * 最大其他
   */
  private java.math.BigDecimal payOtherMax;

  /**
   * 其他 比较(eq)
   */
  private java.math.BigDecimal payOtherEq;
  /**
   * 其他 比较(neq)
   */
  private java.math.BigDecimal payOtherNeq;
  /**
   * 其他 比较(gt)
   */
  private java.math.BigDecimal payOtherGt;
  /**
   * 其他 比较(gte)
   */
  private java.math.BigDecimal payOtherGte;
  /**
   * 其他 比较(lt)
   */
  private java.math.BigDecimal payOtherLt;
  /**
   * 其他 比较(lte)
   */
  private java.math.BigDecimal payOtherLte;
  /**
   * 其他 比较(contains)
   */
  private java.math.BigDecimal payOtherContains;
  /**
   * 其他 比较(notcontains)
   */
  private java.math.BigDecimal payOtherNotcontains;
  /**
   * 其他 比较(startswith)
   */
  private java.math.BigDecimal payOtherStartswith;
  /**
   * 其他 比较(endswith)
   */
  private java.math.BigDecimal payOtherEndswith;
  /**
   * 其他 比较(isnull)
   */
  private Boolean payOtherIsnull;
  /**
   * 其他 比较(isnotnull)
   */
  private Boolean payOtherIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
